In the networked computing environment of today, processes that can run in a number of different environments are becoming increasingly more sought after. One solution for facilitating these types of processes is a process virtual machine. A process virtual machine is generally understood to be a platform dependent engine that executes platform independent code written in a high-level programming language for performing a specific task. Thus, the same code (which can be written in any of a number of different programming languages) can be executed on many different platforms by utilizing a Java Virtual Machine (JVM) that is designed for each platform. One example of a process virtual machine is the JVM used in the JAVA environment (Java and Java Virtual Machine are trademarks of Sun Microsystems in the United States and/or elsewhere), although other implementations are also available. In any case, program code to be executed on process virtual machines (e.g., JVM) is generally not compiled entirely prior to execution of the code (also known as static compilation). Instead, at least a portion of the compiling is instead usually performed at run time (referred to just in time (JIT) compilation).
An optimizing compiler is one that not only compiles program code but optimizes it as it compiles so that it can run more efficiently. In most cases, the optimizing compiler does so by creating an Intermediate Language (IL) representation of the code, often in the format of a graph. This graph usually has a series of nodes, which represent functional processes of the code, joined by pointers. The optimizing compiler may perform several optimization passes over its IL representation, taking the IL representation as input and outputting a changed IL representation (e.g., with additions of, deletions of, and/or changes to nodes, pointers, metadata, and/or the like) that is functionally equivalent but better optimized (by some metric).